Semaphores

Semaphores

The semaphore is a generalized tool that can be used for both mutual exclusion and for waiting. The IRIX kernel support for semaphores is summarized in Table 9-25.

Functions for Semaphores
Function Name Header Files Can Sleep? Purpose
cpsema(D3) sema.h & types.h N Conditionally perform a "P" or wait semaphore operation.
cvsema(D3) sema.h & types.h N Conditionally perform a "V" or release semaphore operation.
freesema(D3) sema.h & types.h N Free the resources associated with a semaphore.
initnsema(D3) sema.h & types.h N Initialize a semaphore to a given value.
initnsema_mutex(D3) sema.h & types.h N Initialize a semaphore to a value of 1.
psema(D3) sema.h & types.h & param.h Y Perform a "P" or wait semaphore operation.
valusema(D3) sema.h & types.h N Return the value associated with a semaphore.
vsema(D3) sema.h & types.h N Perform a "V" or signal semaphore operation.

Functions for Semaphores
Function Name	Header Files	Can Sleep?	Purpose
cpsema(D3)	sema.h & types.h	N	Conditionally perform a "P" or wait semaphore operation.
cvsema(D3)	sema.h & types.h	N	Conditionally perform a "V" or release semaphore operation.
freesema(D3)	sema.h & types.h	N	Free the resources associated with a semaphore.
initnsema(D3)	sema.h & types.h	N	Initialize a semaphore to a given value.
initnsema_mutex(D3)	sema.h & types.h	N	Initialize a semaphore to a value of 1.
psema(D3)	sema.h & types.h & param.h	Y	Perform a "P" or wait semaphore operation.
valusema(D3)	sema.h & types.h	N	Return the value associated with a semaphore.
vsema(D3)	sema.h & types.h	N	Perform a "V" or signal semaphore operation.

Conceptually, a semaphore contains an integer. The "P" operation claims the semaphore, decrementing its count by 1 (mnemonic: dePlete). If the count is 0 or less, the process waits until the count is greater than 0 before it decrements the semaphore and returns.

The "V" operation increments the semaphore count (mnemonic: reViVe) and wakens any process that is waiting.

Tip: When a debugging kernel is used, you can display statistics about the use of a given semaphore. See "Including Lock Metering in the Kernel Image".

Note: In releases before IRIX 6.2, initnsema_mutex() was used to initialize a semaphore in a special way that got the performance of a basic lock in a multiprocessor. Since IRIX 6.2, this function is simply a macro that initializes the semaphore to a count of 1.

Using a Semaphore for Mutual Exclusion

To use a semaphore for locking, initialize it to 1. (This reflects the idea that a process calling a locking function expects to continue.) When you require exclusive use of the associated resource, call psema(). Typically this finds a semaphore count of 1, reduces it to 0, and returns.

When you are finished with the resource, call vsema() to increment the semaphore count, and release any process that is blocked in a psema() call for the same semaphore.

For locking, a semaphore is comparable to a sleep lock. In some systems, the performance of semaphore operations may not be as good as the performance of a mutex lock. In other systems, mutex locks may be implemented using semaphores.

Using a Semaphore for Waiting

To use a semaphore for waiting, initialize it to 0. Then call psema(). Because the semaphore count is 0, the process waits. When the desired event occurs, typically in the interrupt handler, call vsema() to release the waiting process.

This synchronization method is as reliable as a synchronization variable, but it has slightly different behavior. When a synchronization variable is used correctly (see "Using Synchronization Variables"), if the interrupt handler is entered before the SV_WAIT call completes, the interrupt handler waits on a LOCK call.

When a semaphore is used, if the interrupt handler is entered before the psema() call completes, the vsema() operation is done immediately and the interrupt handler continues without waiting. The fact that vsema() was called is stored as a count within the semaphore, where psema() will find it. Because the semaphore can contain this state information, the interrupt handler does not have to be synchronized in time using a lock.

Note: In releases before IRIX 6.2, the vpsema() function was used in a way similar to synchronization variables are used: to release one semaphore and wait on another in an atomic operation. This function is no longer supported; replace it with syncronization variable.